package br.cnpq.webflowah.inferencia;

import java.io.FileNotFoundException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.mindswap.owl.OWLIndividual;
import org.mindswap.owl.OWLIndividualList;
import org.mindswap.owl.OWLKnowledgeBase;
import org.mindswap.owl.OWLOntology;
import org.mindswap.owls.process.AtomicProcess;
import org.mindswap.owls.process.Condition;
import org.mindswap.owls.process.ConditionList;
import org.mindswap.owls.process.Process;
import org.mindswap.owls.process.Input;
import org.mindswap.owls.process.InputList;
import org.mindswap.owls.process.Output;
import org.mindswap.owls.process.OutputList;
import org.mindswap.owls.process.Result;
import org.mindswap.owls.process.ResultList;

import br.cnpq.webflowah.beans.AbstractQualityParameter;
import br.cnpq.webflowah.beans.Conceito;
import br.cnpq.webflowah.beans.Objetivo;
import br.cnpq.webflowah.beans.Operacao;
import br.cnpq.webflowah.ontologia.ConceitoOWL;
import br.cnpq.webflowah.ontologia.Repositorio;

public class SeletorSemantico {

	private OWLKnowledgeBase kb1 = null;

	private OWLKnowledgeBase kb2 = null;

	private Set<Operacao> operacoes = new HashSet<Operacao>();

	private Map<String, Set<Objetivo>> servicos = new HashMap<String, Set<Objetivo>>();

	public SeletorSemantico() {
		try {
			kb1 = Repositorio.newInstance(true);
			kb1.read(ConceitoOWL.OWL_URL);

			kb2 = Repositorio.newInstance(true);
			kb2.read(ConceitoOWL.OWL_URL);
		} catch (FileNotFoundException e) {
		} catch (URISyntaxException e) {
		}
	}

	public void selectOperacao() {
		try {
			List list = ConceitoOWL.recuperarServicos();
			Iterator iter1 = list.iterator();
			while (iter1 != null && iter1.hasNext()) {
				String uri = (String) iter1.next();
				Operacao operacao = new Operacao();
				operacao.setURI(URI.create(uri));
				OWLIndividual ind1 = kb2.getIndividual(URI.create(uri));
				Conceito tarefa = new Conceito();
				tarefa.setNome(ind1.getType().getLocalName());
				tarefa.setURI(ind1.getType().getURI().toString());
				tarefa.setTipo(ConceitoOWL.tarefa);
				OWLIndividual ind2 = ind1.getProperty(
						kb2.getObjectProperty(URI.create(ConceitoOWL.OWL_PROPERTY_ENVOLVE)));
				Conceito objeto = new Conceito();
				objeto.setNome(ind2.getType().getLocalName());
				objeto.setURI(ind2.getType().getURI().toString());
				objeto.setTipo(ConceitoOWL.objeto);
				Objetivo objetivo = new Objetivo();
				objetivo.setTarefa(tarefa);
				objetivo.setObjeto(objeto);
				operacao.setObjetivo(objetivo);
				operacoes.add(operacao);
			}

			iter1 = operacoes.iterator();
			while (iter1 != null && iter1.hasNext()) {
				Operacao operacao = (Operacao) iter1.next();
				String str = operacao.getURI().toString();
				OWLOntology ont = kb1.read(str.substring(0, str.lastIndexOf("#")));
				Process process = ont.getProcess(operacao.getURI());
				if (process instanceof AtomicProcess){
					AtomicProcess atomic = (AtomicProcess) process;
					if (atomic.getGrounding() != null) {
						operacao.setServico("" + atomic.getGrounding().getDescriptionURL());
						Set<Objetivo> set = servicos.get(operacao.getServico());
						if (set == null) {
							set = new HashSet<Objetivo>();
							servicos.put(operacao.getServico(), set);
						}
						set.add(operacao.getObjetivo());
					}
				}
			    InputList inputs = process.getInputs();
			    Iterator iter2 = inputs.iterator();
			    while (iter2.hasNext()) {
			    	Input input = (Input) iter2.next();
			    	OWLIndividual ind = kb2.getIndividual(input.getURI());
			    	operacao.addEntrada(ind.getType().getURI(), input.getURI());
			    }
			    ConditionList conditions = process.getConditions();
			    iter2 = conditions.iterator();
			    while (iter2.hasNext()) {
			    	Condition condition = (Condition) iter2.next();
			    	OWLIndividual ind = kb2.getIndividual(condition.getURI());
			    	operacao.addPrecondicao(ind.getType().getURI(), condition.getURI());
			    }
			    OutputList outputs = process.getOutputs();
			    iter2 = outputs.iterator();
			    while (iter2.hasNext()) {
			    	Output output = (Output) iter2.next();
			    	OWLIndividual ind = kb2.getIndividual(output.getURI());
			    	operacao.addSaida(ind.getType().getURI(), output.getURI());
			    }
			    ResultList results = process.getResults();
			    iter2 = results.iterator();
			    while (iter2.hasNext()) {
			    	Result result = (Result) iter2.next();
			    	OWLIndividualList indList = result.getEffects();
			    	Iterator iter3 = indList.iterator();
				    while (iter3.hasNext()) {
				    	OWLIndividual effect = (OWLIndividual) iter3.next();
				    	OWLIndividual ind = kb2.getIndividual(effect.getURI());
				    	operacao.addEfeito(ind.getType().getURI(), effect.getURI());
				    }
			    }
				kb1.unload(ont);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

//	public void selectOperacao(List<Objetivo> objetivos) {
//		try {
//			// carrega as operacoes disponiveis com base nos objetivos do workflow semantico
//			Iterator iter1 = objetivos.iterator();
//			while (iter1 != null && iter1.hasNext()) {
//				Objetivo objetivo = (Objetivo) iter1.next();
//				List list = ConceitoOWL.recuperarServicos(objetivo);
//				Iterator iter2 = list.iterator();
//				while (iter2 != null && iter2.hasNext()) {
//					String uri = (String) iter2.next();
//					Operacao operacao = new Operacao();
//					operacao.setURI(URI.create(uri));
//					operacao.setObjetivo(objetivo);
//					operacoes.add(operacao);
//				}
//			}
//
//			iter1 = operacoes.iterator();
//			while (iter1 != null && iter1.hasNext()) {
//				Operacao operacao = (Operacao) iter1.next();
//				String str = operacao.getURI().toString();
//				OWLOntology ont = kb1.read(str.substring(0, str.lastIndexOf("#")));
//				Process process = ont.getProcess(operacao.getURI());
//			    InputList inputs = process.getInputs();
//			    Iterator iter2 = inputs.iterator();
//			    while (iter2.hasNext()) {
//			    	Input input = (Input) iter2.next();
//			    	OWLIndividual ind = kb2.getIndividual(input.getURI());
//			    	operacao.addEntradas(ind.getType().getURI(), input.getURI());
//			    }
//			    OutputList outputs = process.getOutputs();
//			    iter2 = outputs.iterator();
//			    while (iter2.hasNext()) {
//			    	Output output = (Output) iter2.next();
//			    	OWLIndividual ind = kb2.getIndividual(output.getURI());
//			    	operacao.addSaidas(ind.getType().getURI(), output.getURI());
//			    }
//				kb1.unload(ont);
//			}
//		} catch (FileNotFoundException e) {
//		} catch (URISyntaxException e) {
//		}
//	}

	public Set<Operacao> getOperacaoPorEntrada(URI uri) {
		try {
			Set<Operacao> set = new HashSet<Operacao>();

			Iterator i = operacoes.iterator();
			while (i.hasNext()) {
			    Operacao operacao = (Operacao) i.next();
			    if (operacao.consomeEntrada(uri))
			    	set.add(operacao);
			}

//			String rdql = "SELECT ?processo\r\n" +
//					"WHERE (?processo rdf:type process:Process)\r\n" +
//					"(?processo process:hasInput ?entrada)\r\n" +
//					"(?entrada rdf:type <" + uri.toString() + ">)\r\n" +
//					"USING\r\n" +
//		            "process FOR <http://www.daml.org/services/owl-s/1.1/Process.owl#>";
//
//			List result = kb.query(rdql);
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//			    ValueMap binding = (ValueMap) i.next();
//			    Process process = (Process) binding.getIndividualValue("processo").castTo(Process.class);
//			    Operacao operacao = new Operacao();
//			    operacao.setURI(process.getURI());
//			    InputList inputs = process.getInputs();
//			    Iterator iter = inputs.iterator();
//			    while (iter.hasNext()) {
//			    	Input input = (Input) iter.next();
//			    	OWLIndividual ind = kb2.getIndividual(input.getURI());
//			    	operacao.addEntradas(ind.getType().getURI(), input.getURI());
//			    }
//			    OutputList outputs = process.getOutputs();
//			    iter = outputs.iterator();
//			    while (iter.hasNext()) {
//			    	Output output = (Output) iter.next();
//			    	OWLIndividual ind = kb2.getIndividual(output.getURI());
//			    	operacao.addSaidas(ind.getType().getURI(), output.getURI());
//			    }
//			    set.add(operacao);
//			}

			return set;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public Set<Operacao> getOperacaoPorEntrada(Operacao[] operacoes, URI uri) {
		Set<Operacao> set = new HashSet<Operacao>();

		for (int i=0; operacoes != null & i < operacoes.length; i++) {
			Operacao operacao = operacoes[i];

			if (operacao.consomeEntrada(uri))
				 set.add(operacao);
		}

		return set;
	}

	public Set<Operacao> getOperacaoPorPrecondicao(Operacao[] operacoes, URI uri) {
		try {
			Set<Operacao> set = new HashSet<Operacao>();

			for (int i=0; operacoes != null & i < operacoes.length; i++) {
				Operacao operacao = operacoes[i];

				if (operacao.consomePrecondicao(uri))
			    	set.add(operacao);
			}

			return set;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public Set<Operacao> getOperacaoPorSaida(URI uri) {
		try {
			Set<Operacao> set = new HashSet<Operacao>();

			Iterator i = operacoes.iterator();
			while (i.hasNext()) {
			    Operacao operacao = (Operacao) i.next();
			    if (operacao.produzSaida(uri))
			    	set.add(operacao);
			}

//			String rdql = "SELECT ?processo\r\n" +
//					"WHERE (?processo rdf:type process:Process)\r\n" +
//					"(?processo process:hasOutput ?saida)\r\n" +
//					"(?saida rdf:type <" + uri.toString() + ">)\r\n" +
//					"USING\r\n" +
//		            "process FOR <http://www.daml.org/services/owl-s/1.1/Process.owl#>";
//
//			List result = kb.query(rdql);
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//			    ValueMap binding = (ValueMap) i.next();
//			    Process process = (Process) binding.getIndividualValue("processo").castTo(Process.class);
//			    Operacao operacao = new Operacao();
//			    operacao.setURI(process.getURI());
//			    InputList inputs = process.getInputs();
//			    Iterator iter = inputs.iterator();
//			    while (iter.hasNext()) {
//			    	Input input = (Input) iter.next();
//			    	OWLIndividual ind = kb2.getIndividual(input.getURI());
//			    	operacao.addEntradas(ind.getType().getURI(), input.getURI());
//			    }
//			    OutputList outputs = process.getOutputs();
//			    iter = outputs.iterator();
//			    while (iter.hasNext()) {
//			    	Output output = (Output) iter.next();
//			    	OWLIndividual ind = kb2.getIndividual(output.getURI());
//			    	operacao.addSaidas(ind.getType().getURI(), output.getURI());
//			    }
//			    set.add(operacao);
//			}

			return set;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public Set<Operacao> getOperacaoPorSaida(Operacao[] operacoes, URI uri) {
		Set<Operacao> set = new HashSet<Operacao>();

		for (int i=0; operacoes != null & i < operacoes.length; i++) {
			Operacao operacao = operacoes[i];

			if (operacao.produzSaida(uri))
				 set.add(operacao);
		}

		return set;
	}

	public Set<Operacao> getOperacaoPorEfeito(Operacao[] operacoes, URI uri) {
		try {
			Set<Operacao> set = new HashSet<Operacao>();

			for (int i=0; operacoes != null & i < operacoes.length; i++) {
				Operacao operacao = operacoes[i];

				if (operacao.produzEfeito(uri))
			    	set.add(operacao);
			}

			return set;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	/**
	 * Seleciona de um conjunto de operacoes aquelas que precisam de uma entrada
	 *
	 */
//	public Set<URI> obterOperacaoPorEntrada(List operacoes, URI uri) {
//		Set<URI> entradas = new HashSet<URI>();
//		entradas.add(uri);
//		return obterOperacaoPorEntrada(operacoes, entradas);
//	}

	/**
	 * Seleciona de um conjunto de operacoes aquelas que precisam de uma entrada
	 *
	 */
//	public Set<URI> obterOperacaoPorEntrada(List operacoes, Set entradas) {
//		try {
//			Set<URI> servicos = new HashSet<URI>();
//
//			Set<URI> result = obterOperacaoPorEntrada(entradas);
//
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//				URI uri = (URI) i.next();
//				if (operacoes.contains(uri))
//					servicos.add(uri);
//			}
//
//			return servicos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona as operacoes que precisam de uma entrada
	 *
	 */
//	public Set<URI> obterOperacaoPorEntrada(Set entradas) {
//		try {
//			Set<URI> servicos = new HashSet<URI>();
////			Set<URI> descarte = new HashSet<URI>();
//
//			String rdql = "SELECT *\r\n" +
//            "WHERE\r\n" +
//            "(?processo rdf:type process:Process)\r\n" +
//            "(?processo process:hasInput ?param)\r\n" +
//            "USING\r\n" +
//            "process FOR <http://www.daml.org/services/owl-s/1.1/Process.owl#>\r\n" +
//            "grounding FOR <http://www.daml.org/services/owl-s/1.1/Grounding.owl#>";
//
//			List result = kb.query(rdql);
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//			    ValueMap binding = (ValueMap) i.next();
//			    Input input = (Input) binding.getIndividualValue("param").castTo(Input.class);
//			    URI operacao = binding.getIndividualValue("processo").getURI();
//
//			    Iterator j = entradas.iterator();
//			    while (j.hasNext()) {
//			    	OWLClass classe = kb.getClass((URI) j.next());
//					// equivalencia de tipos
//			    	if (input.isType(classe)) {
//						servicos.add(operacao);
//					}
//			    }
//			}
//
//			return servicos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona de um conjunto de operacoes aquelas que produzem uma saida
	 *
	 */
//	public Set<URI> obterOperacaoPorSaida(List operacoes, URI uri) {
//		Set<URI> saidas = new HashSet<URI>();
//		saidas.add(uri);
//		return obterOperacaoPorSaida(operacoes, saidas);
//	}

	/**
	 * Seleciona de um conjunto de operacoes aquelas que produzem uma saida
	 *
	 */
//	public Set<URI> obterOperacaoPorSaida(List operacoes, Set saidas) {
//		try {
//			Set<URI> servicos = new HashSet<URI>();
//
//			Set<URI> result = obterOperacaoPorSaida(saidas);
//
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//				URI uri = (URI) i.next();
//				if (operacoes.contains(uri))
//					servicos.add(uri);
//			}
//
//			return servicos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona as operacoes que produzem uma saida
	 *
	 */
//	public Set<URI> obterOperacaoPorSaida(Set saidas) {
//		try {
//			Set<URI> servicos = new HashSet<URI>();
//
//			String rdql = "SELECT *\r\n" +
//            "WHERE\r\n" +
//            "(?processo rdf:type process:Process)\r\n" +
//            "(?processo process:hasOutput ?param)\r\n" +
//            "USING\r\n" +
//            "process FOR <http://www.daml.org/services/owl-s/1.1/Process.owl#>\r\n" +
//            "grounding FOR <http://www.daml.org/services/owl-s/1.1/Grounding.owl#>";
//
//			List result = kb.query(rdql);
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//			    ValueMap binding = (ValueMap) i.next();
//			    Output output = (Output) binding.getIndividualValue("param").castTo(Output.class);
//
//			    Iterator j = saidas.iterator();
//			    while (j.hasNext()) {
//					OWLClass classe = kb.getClass((URI) j.next());
//					// equivalencia de tipos
//			    	if (output.isType(classe))
//						servicos.add(binding.getIndividualValue("processo").getURI());
//			    }
//			}
//
//			return servicos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona de um conjunto de operacoes aquelas que implementam uma atividade
	 *
	 */
//	public Set<URI> obterOperacaoPorAtividade(List operacoes, Objetivo atividade) {
//		Set<Objetivo> atividades = new HashSet<Objetivo>();
//		atividades.add(atividade);
//		return obterOperacaoPorAtividade(operacoes, atividades);
//	}

	/**
	 * Seleciona de um conjunto de operacoes aquelas que implementam uma atividade
	 *
	 */
//	public Set<URI> obterOperacaoPorAtividade(List operacoes, Set atividades) {
//		try {
//			Set<URI> servicos = new HashSet<URI>();
//
//			Set<URI> result = obterOperacaoPorAtividade(atividades);
//
//			Iterator i = result.iterator();
//			while (i.hasNext()) {
//				URI uri = (URI) i.next();
//				if (operacoes.contains(uri))
//					servicos.add(uri);
//			}
//
//			return servicos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona as operacoes que implementam uma atividade
	 *
	 */
	public Set<Operacao> getOperacaoPorObjetivo(List objetivos) {
		try {
			Set<Operacao> set = new HashSet<Operacao>();

//			Iterator i = operacoes.iterator();
//			while (i.hasNext()) {
//			    Operacao operacao = (Operacao) i.next();
//				Objetivo objetivo = operacao.getObjetivo();
//
//				Iterator j = objetivos.iterator();
//				while (j.hasNext()) {
//					Objetivo outro = (Objetivo) j.next();
//					if (outro.equals(objetivo))
//						set.add(operacao);
//				}
//			}

			Iterator iter = objetivos.iterator();
			while (iter.hasNext()) {
				Objetivo objetivo = (Objetivo) iter.next();
//				Set<Operacao> temp1 = new HashSet<Operacao>();
//				Set<Operacao> temp2 = getOperacaoPorObjetivo(operacoes.toArray(new Operacao[0]), objetivo);
//
//				List list = objetivo.getSaidas();
//				for (int i=0; list != null && i < list.size(); i++) {
//					Conceito conceito = (Conceito) list.get(i);
//					URI uri = URI.create(conceito.getURI());
//					temp1.addAll(getOperacaoPorSaida(temp2.toArray(new Operacao[0]), uri));
//				}
//
//				if (temp1.size() > 0) {
//					temp2 = temp1;
//					temp1 = new HashSet<Operacao>();
//				}
//
//				list = objetivo.getPreCondicoes();
//				for (int i=0; list != null && i < list.size(); i++) {
//					Conceito conceito = (Conceito) list.get(i);
//					URI uri = URI.create(conceito.getURI());
//					temp1.addAll(getOperacaoPorPrecondicao(temp2.toArray(new Operacao[0]), uri));
//				}
//
//				if (temp1.size() > 0) {
//					temp2 = temp1;
//					temp1 = new HashSet<Operacao>();
//				}
//
//				list = objetivo.getEfeitos();
//				for (int i=0; list != null && i < list.size(); i++) {
//					Conceito conceito = (Conceito) list.get(i);
//					URI uri = URI.create(conceito.getURI());
//					temp1.addAll(getOperacaoPorEfeito(temp2.toArray(new Operacao[0]), uri));
//				}
//
//				if (temp1.size() == 0) temp1 = temp2;
//
//				set.addAll(temp1);
				set.addAll(getOperacaoPorObjetivo(operacoes.toArray(new Operacao[0]), objetivo));
			}

			return set;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public Set<Operacao> getOperacaoPorObjetivo(Operacao[] operacoes, Objetivo objetivo) {
		Set<Operacao> set = new HashSet<Operacao>();

		for (int i=0; operacoes != null & i < operacoes.length; i++) {
			Operacao operacao = operacoes[i];

			if (operacao.getObjetivo().equals(objetivo)){
				//FRED: incluí esse if abaixo (2 linhas abaixo)...
				if(objetivo.getImpactoDesejado() != null)
					operacao.getObjetivo().setImpactoDesejado(objetivo.getImpactoDesejado());
				else
					operacao.getObjetivo().setImpactoDesejado(AbstractQualityParameter.NONE);

				set.add(operacao);
			}
		}

		return set;
	}

	public Set<Objetivo> getObjetivoPorServico(String[] list) {
		Set<Objetivo> set = new HashSet<Objetivo>();

		for (int i=0; list != null && i < list.length; i++) {
			set.addAll(servicos.get(list[i]));
		}

		return set;
	}

	/**
	 * Seleciona as entradas de uma operacao
	 *
	 */
//	public Set<URI> obterEntradaPorOperacao(URI uri) {
//		Set<URI> operacoes = new HashSet<URI>();
//		operacoes.add(uri);
//		return obterEntradaPorOperacao(operacoes);
//	}

	/**
	 * Seleciona as entradas de uma operacao
	 *
	 */
//	public Set<URI> obterEntradaPorOperacao(Set operacoes) {
//		try {
//			Set<URI> conceitos = new HashSet<URI>();
//
//			Iterator i = operacoes.iterator();
//			while (i.hasNext()) {
//				OWLIndividual ind = kb.getIndividual((URI) i.next());
//				Process process = (Process) ind.castTo(Process.class);
//				InputList inputs = process.getInputs();
//
//				for (int j=0; j < inputs.size(); j++) {
//					Input input = (Input)inputs.get(j);
//					Conceito tipo = ConceitoOWL.recuperarTipo(input.getURI());
//					conceitos.add(URI.create(tipo.getURI()));
//				}
//			}
//
//			return conceitos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona as entradas de um caminho
	 *
	 */
//	public List<URI> obterEntradaPorOperacao(List operacoes) {
//		try {
//			List<URI> conceitos = new ArrayList<URI>();
//
//			Iterator i = operacoes.iterator();
//			while (i.hasNext()) {
//				OWLIndividual ind = kb.getIndividual((URI) i.next());
//				Process process = (Process) ind.castTo(Process.class);
//				InputList inputs = process.getInputs();
//
//				for (int j=0; j < inputs.size(); j++) {
//					Input input = (Input)inputs.get(j);
//					Conceito tipo = ConceitoOWL.recuperarTipo(input.getURI());
//					conceitos.add(URI.create(tipo.getURI()));
//				}
//			}
//
//			return conceitos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona as saidas de uma operacao
	 *
	 */
//	public Set<URI> obterSaidaPorOperacao(URI uri) {
//		Set<URI> operacoes = new HashSet<URI>();
//		operacoes.add(uri);
//		return obterSaidaPorOperacao(operacoes);
//	}

	/**
	 * Seleciona as saidas de uma operacao
	 *
	 */
//	public Set<URI> obterSaidaPorOperacao(Set operacoes) {
//		try {
//			Set<URI> conceitos = new HashSet<URI>();
//
//			Iterator i = operacoes.iterator();
//			while (i.hasNext()) {
//				OWLIndividual ind = kb.getIndividual((URI) i.next());
//				Process process = (Process) ind.castTo(Process.class);
//				OutputList outputs = process.getOutputs();
//
//				for (int j=0; j < outputs.size(); j++) {
//					Output output = (Output)outputs.get(j);
//					Conceito tipo = ConceitoOWL.recuperarTipo(output.getURI());
//					conceitos.add(URI.create(tipo.getURI()));
//				}
//			}
//
//			return conceitos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona as saidas de uma operacao
	 *
	 */
//	public List<URI> obterSaidaPorOperacao(List operacoes) {
//		try {
//			List<URI> conceitos = new ArrayList<URI>();
//
//			Iterator i = operacoes.iterator();
//			while (i.hasNext()) {
//				OWLIndividual ind = kb.getIndividual((URI) i.next());
//				Process process = (Process) ind.castTo(Process.class);
//				OutputList outputs = process.getOutputs();
//
//				for (int j=0; j < outputs.size(); j++) {
//					Output output = (Output)outputs.get(j);
//					Conceito tipo = ConceitoOWL.recuperarTipo(output.getURI());
//					conceitos.add(URI.create(tipo.getURI()));
//				}
//			}
//
//			return conceitos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona atividades implementadas por uma operacao
	 *
	 */
//	public Set<Objetivo> getAtividadePorOperacao(Set operacoes) {
//		try {
//			Set<Objetivo> set = new HashSet<Objetivo>();
//
//			Iterator i = operacoes.iterator();
//			while (i.hasNext()) {
////				Conceito conceito = ConceitoOWL.recuperar((URI) i.next());
////				Objetivo objetivo = new Objetivo();
////				objetivo.setTarefa(conceito.getTipo());
////				List objetos = conceito.getAssociacoes();
////				if (objetos != null && objetos.size() > 0) {
////					Conceito associacao = (Conceito) objetos.get(0);
////					conceito = ConceitoOWL.recuperar(URI.create(associacao.getURI()));
////					objetivo.setObjeto(conceito.getTipo());
////				}
//				Operacao operacao = (Operacao) i.next();
//				Objetivo objetivo = operacao.getObjetivo();
//
//				if (!set.contains(objetivo))
//					set.add(objetivo);
//			}
//
//			return set;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

	/**
	 * Seleciona saidas geradas por uma atividade
	 *
	 */
//	public Set<URI> obterSaidaPorAtividade(URI uri) {
//		try {
//			Set<URI> conceitos = new HashSet<URI>();
//
//			OWLIndividual ind = kb.getIndividual(uri);
//			AtomicProcess process = (AtomicProcess) ind.castTo(AtomicProcess.class);
//			OutputList outputs = process.getOutputs();
//
//			for (int j=0; j < outputs.size(); j++) {
//				Output output = (Output)outputs.get(j);
//				conceitos.add(output.getParamType().getURI());
//			}
//
//			return conceitos;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		return null;
//	}

}
